package cn.lyd.pet.service.impl;

import cn.lyd.base.until.BussinessException;
import cn.lyd.pet.domain.Pet;
import cn.lyd.pet.domain.PetType;
import cn.lyd.pet.mapper.PetMapper;
import cn.lyd.pet.mapper.PetTypeMapper;
import cn.lyd.pet.service.IPetTypeService;
import cn.lyd.base.service.impl.BaseServiceImpl;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author lyd
 * @since 2023-01-08
 */
@Service
public class PetTypeServiceImpl extends BaseServiceImpl<PetType> implements IPetTypeService {

    @Autowired
    private PetTypeMapper petTypeMapper;
    @Autowired
    private PetMapper petMapper;


    /**
     * 无限级数-宠物类型
     * @return
     */
    @Override
    public List<PetType> tree() {
        //todo 宠物类型 无限级树
        //先查出所有的宠物类型集合
        List<PetType> petTypeList = petTypeMapper.findAll();

        //key: 宠物类型id value：宠物类型集合
        Map<Long, PetType> Id_PetType_List = petTypeList.stream().collect(Collectors.toMap(PetType::getId, item -> item));


        //类型树集合
        List<PetType> petTree = new ArrayList<>();

        //遍历所有类型，没有父级id=顶级类型
        for (PetType petType : petTypeList){
            //没有父级id=顶级类型，放到类型树里
            if (petType.getParent_id()==null) {
                petTree.add(petType);
            }else {//有父级id
                //先获取他的父级类型
                PetType parentPetType = Id_PetType_List.get(petType.getParent_id());
                if (parentPetType!=null) {
                    //把这个子类型放到父级类型的children里
                    parentPetType.getChildren().add(petType);
                }
            }
        }
        return petTree;

    }


    /**
     * 重写宠物类型添加：添加上级类型
     * @param petType
     */
    @Override
    public void add(PetType petType) {
        PetType addPetType = new PetType();
        addPetType.setId(petType.getId());
        addPetType.setName(petType.getName());
        addPetType.setDescription(petType.getDescription());
        //判断前端是否选择了类型
        if (petType.getParent_id()!=null){
            addPetType.setParent_id(petType.getParent_id());
        }
        super.add(addPetType);
    }


    /**
     * 重写删除宠物类型：
     *                  如果删除的类型有子类型，不允许删除，
     *                  方案1：如果删除的类型没有子类型，且属于该类型的宠物有处于上架状态的,不允许删除
     *            采用  方案2：如果删除的类型没有子类型，有宠物属于该类型，不允许删除，没有宠物就删除
     * @param id    要删除的类型id
     */
    @Override
    public void delete(Long id) {
        //1.要删除的类型对象
        PetType delPetType = petTypeMapper.findByIdToDel(id);
        //2.获取当前类型的子类型集合
        List<PetType> children = delPetType.getChildren();
        //子类型不是空集合
        if(!children.isEmpty()){
            throw new BussinessException("当前类型存在子类型,请先删除子类型");
        }else {//子类型是空集合,判断有无宠物---没有就删除类型
            //获取属于该类型的宠物集合
            List<Pet> petList = petMapper.findByTypeId(id);
            //判断有无宠物属于该类型==是不是空集合，有宠物就抛异常，没有就删除类型
            if (petList.isEmpty()){//没有宠物就删除该类型
                super.delete(id);
            }else {//有宠物就抛异常
                throw new BussinessException("有宠物属于该类型，无法删除!");
            }
        }
    }
}
